package com.foreveross.fetl.util;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.StringReader;
import java.util.Enumeration;

import org.apache.tools.zip.ZipEntry;
import org.apache.tools.zip.ZipFile;
import org.apache.tools.zip.ZipOutputStream;

/** *//**
* 压缩/解压缩zip包 和 文件 处理类
* 
*/

 public class ZipUtils {

   /** *//**
    * 压缩
    * 
    * @param zipFileName
    *            压缩产生的zip包文件名--带路径,如果为null或空则默认按文件名生产压缩文件名
    * @param relativePath
    *            相对路径，默认为空
    * @param directory
    *            文件或目录的绝对路径
    * @throws FileNotFoundException
    * @throws IOException
    * @author yayagepei
    * @date 2008-8-26
    */
   public static void zip(String zipFileName, String relativePath,
           String directory) throws FileNotFoundException, IOException {
       String fileName = zipFileName;
       if (fileName == null || fileName.trim().equals("")) {
           File temp = new File(directory);
           if (temp.isDirectory()) {
               fileName = directory + ".zip";
           } else {
               if (directory.indexOf(".") > 0) {
                   fileName = directory.substring(0, directory
                           .lastIndexOf("."))
                           + "zip";
               } else {
                   fileName = directory + ".zip";
               }
           }
       }
       ZipOutputStream zos = new ZipOutputStream(
               new FileOutputStream(fileName));
       try {
           zip(zos, relativePath, directory);
       } catch (IOException ex) {
           throw ex;
       } finally {
           if (null != zos) {
               zos.close();
           }
       }
   }
   
   /**

    * 生产文件 如果文件所在路径不存在则生成路径

    * 

    * @param fileName

    *            文件名 带路径

    * @param isDirectory 是否为路径

    * @return

    * @author yayagepei

    * @date 2008-8-27

    */

   public static File buildFile(String fileName, boolean isDirectory) {

       File target = new File(fileName);

       if (isDirectory) {

           target.mkdirs();

       } else {

           if (!target.getParentFile().exists()) {

               target.getParentFile().mkdirs();

               target = new File(target.getAbsolutePath());

           }

       }

       return target;

   }
   
   /**
    * 删除指定文件夹下所有文件
    * @param path 文件夹完整绝对路径
    * @return
    */
   public static boolean delAllFile(String path) {
       boolean flag = false;
       File file = new File(path);
       if (!file.exists()) {
         return flag;
       }
       if (!file.isDirectory()) {
         return flag;
       }
       String[] tempList = file.list();
       File temp = null;
       for (int i = 0; i < tempList.length; i++) {
          if (path.endsWith(File.separator)) {
             temp = new File(path + tempList[i]);
          } else {
              temp = new File(path + File.separator + tempList[i]);
          }
          if (temp.isFile()) {
             temp.delete();
          }
          if (temp.isDirectory()) {
             delAllFile(path + "/" + tempList[i]);//先删除文件夹里面的文件
             delFolder(path + "/" + tempList[i]);//再删除空文件夹
             flag = true;
          }
       }
       return flag;
     }
   
   /**
    * 删除文件夹
    * @param folderPath 文件夹完整绝对路径
    */
   public static void delFolder(String folderPath) {
	     try {
	        delAllFile(folderPath); //删除完里面所有内容
	        String filePath = folderPath;
	        filePath = filePath.toString();
	        java.io.File myFilePath = new java.io.File(filePath);
	        myFilePath.delete(); //删除空文件夹
	     } catch (Exception e) {
	       e.printStackTrace(); 
	     }
	}

   

   /** *//**
    * 压缩
    * 
    * @param zos
    *            压缩输出流
    * @param relativePath
    *            相对路径
    * @param absolutPath
    *            文件或文件夹绝对路径
    * @throws IOException
    * @author yayagepei
    * @date 2008-8-26
    */
   private static void zip(ZipOutputStream zos, String relativePath,
           String absolutPath) throws IOException {
       File file = new File(absolutPath);
       if (file.isDirectory()) {
           File[] files = file.listFiles();
           for (int i = 0; i < files.length; i++) {
               File tempFile = files[i];
               if (tempFile.isDirectory()) {
                   String newRelativePath = relativePath + tempFile.getName()
                           + File.separator;
                   createZipNode(zos, newRelativePath);
                   zip(zos, newRelativePath, tempFile.getPath());
               } else {
                   zipFile(zos, tempFile, relativePath);
               }
           }
       } else {
           zipFile(zos, file, relativePath);
       }
   }

   /** *//**
    * 压缩文件
    * 
    * @param zos
    *            压缩输出流
    * @param file
    *            文件对象
    * @param relativePath
    *            相对路径
    * @throws IOException
    * @author yayagepei
    * @date 2008-8-26
    */
   private static void zipFile(ZipOutputStream zos, File file,
           String relativePath) throws IOException {
       ZipEntry entry = new ZipEntry(relativePath + file.getName());
       zos.putNextEntry(entry);
       InputStream is = null;
       try {
           is = new FileInputStream(file);
           int BUFFERSIZE = 2 << 10;
           int length = 0;
           byte[] buffer = new byte[BUFFERSIZE];
           while ((length = is.read(buffer, 0, BUFFERSIZE)) >= 0) {
               zos.write(buffer, 0, length);
           }
           zos.flush();
           zos.closeEntry();
       } catch (IOException ex) {
           throw ex;
       } finally {
           if (null != is) {
               is.close();
           }
       }
   }

   /** *//**
    * 创建目录
    * 
    * @param zos
    *            zip输出流
    * @param relativePath
    *            相对路径
    * @throws IOException
    * @author yayagepei
    * @date 2008-8-26
    */
   private static void createZipNode(ZipOutputStream zos, String relativePath)
           throws IOException {
       ZipEntry zipEntry = new ZipEntry(relativePath);
       zos.putNextEntry(zipEntry);
       zos.closeEntry();
   }

   /** *//**
    * 解压缩zip包
    * 
    * @param zipFilePath
    *            zip文件路径
    * @param targetPath
    *            解压缩到的位置，如果为null或空字符串则默认解压缩到跟zip包同目录跟zip包同名的文件夹下
    * @throws IOException
    * @author yayagepei
    * @date 2008-9-28
    */
   public static void unzip(String zipFilePath, String targetPath)
           throws IOException {
       OutputStream os = null;
       InputStream is = null;
       ZipFile zipFile = null;
       try {
           zipFile = new ZipFile(zipFilePath);
           String directoryPath = "";
           if (null == targetPath || "".equals(targetPath)) {
               directoryPath = zipFilePath.substring(0, zipFilePath
                       .lastIndexOf("."));
           } else {
               directoryPath = targetPath;
           }
           Enumeration entryEnum = zipFile.getEntries();
           if (null != entryEnum) {
               ZipEntry zipEntry = null;
               while (entryEnum.hasMoreElements()) {
                   zipEntry = (ZipEntry) entryEnum.nextElement();
                   if (zipEntry.isDirectory()) {
                       directoryPath = directoryPath + File.separator
                               + zipEntry.getName();
                       System.out.println(directoryPath);
                       continue;
                   }
                   if (zipEntry.getSize() > 0) {
                       // 文件
                       File targetFile =buildFile(directoryPath
                               + File.separator + zipEntry.getName(), false);
                       os = new BufferedOutputStream(new FileOutputStream(
                               targetFile));
                       is = zipFile.getInputStream(zipEntry);
                       byte[] buffer = new byte[4096];
                       int readLen = 0;
                       while ((readLen = is.read(buffer, 0, 4096)) >= 0) {
                           os.write(buffer, 0, readLen);
                       }

                       os.flush();
                       os.close();
                   } else {
                       // 空目录
                     buildFile(directoryPath + File.separator
                               + zipEntry.getName(), true);
                   }
               }
           }
       } catch (IOException ex) {
           throw ex;
       } finally {
           if(null != zipFile){
               zipFile = null;
           }
           if (null != is) {
               is.close();
           }
           if (null != os) {
               os.close();
           }
       }
   }
   
	/**
	 * InputStream 转为 file
	 * @param ins
	 * @param file
	 */
	public static void inputstreamtofile(InputStream ins,File file) {
		 OutputStream os=null;
		  try {
		    os = new FileOutputStream(file);
		   int bytesRead = 0;
		   byte[] buffer = new byte[8192];
		   while ((bytesRead = ins.read(buffer, 0, 8192)) != -1) {
		    os.write(buffer, 0, bytesRead);
		   }
		   os.close();
		   ins.close();
		  } catch (Exception e) {
		   e.printStackTrace();
		  }finally{
			 if(null!= os){
				 try {
					os.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			 }
		  }
	}
  
	/**
	 * 根据输入的文件与输出流对文件进行打包
	 * 
	 * @param File
	 * @param org
	 *            .apache.tools.zip.ZipOutputStream
	 */
	public  static void zipFile(File inputFile, ZipOutputStream ouputStream) {
		try {
			if (inputFile.exists()) {
				/**
				 * 如果是目录的话这里是不采取操作的， 至于目录的打包正在研究中
				 */
				if (inputFile.isFile()) {
					FileInputStream IN = new FileInputStream(inputFile);
					BufferedInputStream bins = new BufferedInputStream(IN, 512);
					// org.apache.tools.zip.ZipEntry
					ZipEntry entry = new ZipEntry(inputFile.getName());
					ouputStream.putNextEntry(entry);
					// 向压缩文件中输出数据
					int nNumber;
					byte[] buffer = new byte[512];
					while ((nNumber = bins.read(buffer)) != -1) {
						ouputStream.write(buffer, 0, nNumber);
					}
					// 关闭创建的流对象
					bins.close();
					IN.close();
				} else {
					try {
						File[] files = inputFile.listFiles();
						for (int i = 0; i < files.length; i++) {
							zipFile(files[i], ouputStream);
						}
					} catch (Exception e) {
						e.printStackTrace();
					}
				}
			}
    } catch (Exception e) {
            e.printStackTrace();
        }
    }
	
	/**
	 * 创建文件
	 * @param path 文件路径
	 * @param name 文件名
	 * @param json 内容
	 */
	public static void creatFile(String path,String name,String json){
		if(null!=path && !path.endsWith("/")){
			path+="/";
		}
		File f=null;
		if(name !=null || !"".equals(name)){
			f=new File(path+name);
		}else{
			f=new File(path);
		}
		BufferedReader bufferedReader =null; 
		BufferedWriter bufferedWriter =null;
		try {
			
			if (!f.exists()) {
				File fileDir=new File(path);
				if(!fileDir.exists()){
					fileDir.mkdirs();
				}
				f.createNewFile(); 
			}
			bufferedReader = new BufferedReader(new StringReader(json));
			bufferedWriter = new BufferedWriter(new FileWriter(f));
			char buffer[] = new char[1024];  
            int len;  
            while ((len = bufferedReader.read(buffer)) != -1) {  
                bufferedWriter.write(buffer, 0, len);  
            }  
            bufferedWriter.flush();  
            bufferedReader.close();  
            bufferedWriter.close();
            f=null;
		} catch (Exception e) {
			System.out.println( name+"  create file fail");
			e.printStackTrace();
		} finally {
			if(null!=bufferedReader){
				try {
					bufferedReader.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if(null!=bufferedWriter){
				 try {
					bufferedWriter.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			
		}
		
		
	}

 }
 
